This is a follow up to my previous cpp generator rework and is what I was aiming for in the first place.

Class and interface generation (as well as native and managed variants) was contained in one big function with a sprawling set of if statements to generate code based on those 4 types. Incorrect branches being taken has been the root of several bugs and the code in general is very unweildy and hard to extend.
When module level functions came out I had a go at extending the generator to output these as namespace level functions / variables but gave up as adding an extra variant was too much to deal with.

So now the cpp generate splits types into one of 5 categories, native class, managed class, native interface, managed interface. or enums. There are now dedicated generator functions for the header and implementation code of these 5 types which is mostly stitching together calls to shared functions with very little branching involved.

The fields for the class and interface types are also split up to make the generators work easier. tclass_fields are divided up into variables (physical), properties (non physical), functions, and dynamic functions. This means that areas such as generating mark and visit functions only need to iterate over the variables which makes the code much easier to follow. Previously it was iterating over all fields and needing to filter out dynamic functions, non physical fields, etc.

This division works really well and there is no case where parts of the generator needs to then further filter the lists which is quite satisfying. When these fields get split up we also handle various hxcpp implementation details. E.g. dynamic functions will put a variable into othe variable list, abstract functions will place a no-op function into the function list, and variables with default functions will place a dynamic function into the dynamic function list. These means a lot of the edge cases which were handled multiple times in various places in the generator are now handled once at retyping which, again, simplifies the generators code.

Some stuff such as class Ids and interface slots are now assigned during retyping which means the context is now more immutable.

There was more I was thinking of doing such as the retyped classes containg tcpp expressions and types but this has been going on for quite a while now and I think its good enough. I've manually ran the hxcpp test suite and it all passes and I've ran some of the tests with the generational GC and that still works.